/*
 * @Author: 13177709051 3506463075@qq.com
 * @Date: 2024-10-20 14:59:49
 * @LastEditors: 13177709051 3506463075@qq.com
 * @LastEditTime: 2024-10-20 16:29:49
 * @FilePath: /linux15/hello.c
 * @Description: 这是默认设置,请设置`customMade`, 打开koroFileHeader查看配置 进行设置: https://github.com/OBKoro1/koro1FileHeader/wiki/%E9%85%8D%E7%BD%AE
 */
// #include <stdio.h>
// #include <string.h>

// int main()
// {
//     FILE *fp = fopen("myfile", "w");
//     if(!fp) printf("fopen error!\n");

//     const char* msg = "hello C programming language";
//     int count = 5;
//     while(count--) fwrite(msg, strlen(msg), 1, fp);

//     fclose(fp);

//     return 0;
// }

// FILE *fp：定义一个指向 FILE 结构的指针 fp，用于处理文件操作。
// fopen("myfile", "w")：
// 尝试以写入模式（"w"）打开名为 "myfile" 的文件。
// 如果文件不存在，fopen 会创建一个新的空文件。
// 如果文件已经存在，内容会被清空。

// fwrite(msg, strlen(msg), 1, fp)：
// msg：要写入的内容。
// strlen(msg)：要写入的字节数（字符串的长度）。
// 1：要写入的块数。
// fp：目标文件指针。

// 使用 fclose(fp) 关闭打开的文件，确保所有缓存的内容被写入磁盘，并释放系统资源。

// int main()
// {
//     FILE* fp = fopen("myfile", "r");
//     if(!fp) printf("fopen error!\n");

//     char buf[1024];
//     const char * msg = "hello linux!\n";
//     while(1)
//     {
//         size_t s = fread(buf, 1, strlen(msg), fp);
//         if(s > 0)
//         {
//             buf[s] = 0;
//             printf("%s", buf);
//         }
//         if(feof(fp)) break;
//     }
//     fclose(fp);
//     return 0;
// }

// 使用 fopen 函数以只读模式（"r"）打开名为 "myfile" 的文件。如果文件打开失败（如文件不存在），fopen 将返回 NULL，程序会打印错误信息。

// while(1) 创建一个无限循环。
// 使用 fread 函数从文件中读取数据：
// 第一个参数是目标缓冲区 buf，第二个参数是每次读取的字节大小（1），第三个参数是要读取的字节数（这里是 strlen(msg)，即 13 字节）。
// 如果 fread 成功读取到数据，则 s 将大于 0。
// 通过 buf[s] = 0; 将读取的数据结尾标志设置为 '\0'，以确保后续的 printf 函数正确打印字符串。
// 然后使用 printf 输出读取到的内容。
// 使用 feof(fp) 检查文件是否结束，如果是，则跳出循环。

// 关闭打开的文件，释放系统资源。

// #include <stdio.h>
// #include <string.h>

// int main()
// {
//     const char *msg = "hello fwrite\n";
//     fwrite(msg, strlen(msg), 1, stdout);

//     printf("hello printf\n");
//     fprintf(stdout, "hello fprintf\n");
//     return 0;
// }

// fwrite 函数用于从内存块写入数据到文件或输出流。

// 第一个参数是待写入的内存地址，这里是 msg。
// 第二个参数是每个元素的大小，这里是 strlen(msg)，表示字符串的长度（即 14 字节，包括换行符）。
// 第三个参数是要写入的元素个数，这里为 1，表示写入一个块。
// 第四个参数是目标输出流，这里是 stdout，标准输出。

// printf 是一个格式化输出函数，输出字符串 "hello printf\n" 到标准输出。

// fprintf 是一个格式化输出函数，功能与 printf 类似，但可以将输出写入指定的文件流。
// 第一个参数是目标输出流，这里为 stdout，第二个参数是待输出的字符串。
// 这行代码的效果与 printf 相同，即将字符串 "hello fprintf\n" 输出到标准输出。

//  The fopen() function opens the file whose name is the string pointed to by pathname and associates a stream with it.

//        The argument mode points to a string beginning with one of the following sequences (possibly followed by additional characters, as described below):

//        r      Open text file for reading.  The stream is positioned at the beginning of the file.

//        r+     Open for reading and writing.  The stream is positioned at the beginning of the file.

//        w      Truncate file to zero length or create text file for writing.  The stream is positioned at the beginning of the file.

//        w+     Open for reading and writing.  The file is created if it does not exist, otherwise it is truncated.  The stream is positioned at the beginning of the file.

//        a      Open for appending (writing at end of file).  The file is created if it does not exist.  The stream is positioned at the end of the file.

//        a+     Open  for reading and appending (writing at end of file).  The file is created if it does not exist.  Output is always appended to the end of the file.  POSIX
//               is silent on what the initial read position is when using this mode.  For glibc, the initial file position for reading is at the beginning of  the  file,  but
//               for Android/BSD/MacOS, the initial file position for reading is at the end of the file.

// #include <stdio.h>
// #include <sys/types.h>
// #include <sys/stat.h>
// #include <fcntl.h>
// #include <uchar.h>
// #include <string.h>
// #include <stdio.h>
// #include <sys/types.h>
// #include <sys/stat.h>
// #include <fcntl.h>
// #include <unistd.h>
// #include <string.h>

// int main()
// {
//     umask(0);
//     int fd = open("myfile", O_WRONLY|O_CREAT, 0644);
//     if(fd < 0)
//     {
//         perror("open");
//         return 1;
//     }
//     int count = 5;
//     const char *msg = "hello world!\n";
//     int len = strlen(msg);
//     while(count--)
//     {
//         write(fd, msg, len);
//     }
//     close(fd);
//     return 0;
// }

// #include <stdio.h>
// #include <sys/types.h>
// #include <sys/stat.h>
// #include <fcntl.h>
// #include <unistd.h>
// #include <string.h>
// int main()
// {
//     umask(0);
//     int fd = open("myfile", O_WRONLY | O_CREAT, 0644);
//     if (fd < 0)
//     {
//         perror("open");
//         return 1;
//     }
//     int count = 5;
//     const char *msg = "hello bit!\n";
//     int len = strlen(msg);
//     while (count--)
//     {
//         write(fd, msg, len);
//     }
//     close(fd);
//     return 0;
// }


// umask(0)：设置进程的文件模式创建掩码为 0。这意味着后续创建的文件将使用其指定的权限，不受默认掩码的影响。通常情况下，系统会有一个默认的掩码，设置为 0 可以确保文件创建时使用的权限为0644。

// open 函数用于打开文件。

// 第一个参数 "myfile" 是要打开或创建的文件名。
// 第二个参数是打开模式，这里使用了两个标志：
// O_WRONLY：以只写模式打开文件。
// O_CREAT：如果文件不存在，则创建一个新文件。
// 第三个参数 0644 是文件权限，仅在文件创建时有效。它表示：
// 所有者具有读写权限（6），
// 同组用户具有读权限（4），
// 其他用户也具有读权限（4）。
// fd 是返回的文件描述符。如果打开失败，返回值将为负数。


// write(fd, msg, len);：
// 第一个参数 fd 是文件描述符。
// 第二个参数 msg 是要写入的内容。
// 第三个参数 len 是要写入的字节数。



// #include <stdio.h>
// #include <sys/types.h>
// #include <sys/stat.h>
// #include <fcntl.h>
// #include <unistd.h>
// #include <string.h>

// int main()
// {
//     int fd = open("myfile", O_RDONLY);
//     if(fd < 0) 
//     {
//         perror("open");
//         return 1;
//     }
//     const char* msg = "hello world!\n";
//     char buf[1024];
//     while(1)
//     {
//         size_t s = read(fd, buf, strlen(msg));
//         if(s > 0) printf("%s", buf);
//         else break;
//     }
//     close(fd);
//     return 0;
// }



// open 函数用于打开文件。

// 第一个参数 "myfile" 是要打开的文件名。
// 第二个参数 O_RDONLY 表示以只读模式打开文件。
// fd 是返回的文件描述符。如果打开失败，返回值将为负数。

// size_t s = read(fd, buf, strlen(msg));：
// 使用 read 函数从文件描述符 fd 读取数据。
// 第一个参数 fd 是文件描述符。
// 第二个参数 buf 是用来存储读取数据的缓冲区。
// 第三个参数是 strlen(msg)，即读取 msg 字符串的长度（12 字节）。
// if(s > 0)：

// 检查返回的字节数 s 是否大于 0。如果大于 0，表示成功读取了数据。
// printf("%s", buf);：将缓冲区 buf 中的数据打印到标准输出。